/**
 * 软件著作权：
 *
 * 系统名称：  云序列
 *
 * 文件名称：  ImpulseSenderService.java
 *
 * 功能描述：  发号器服务
 * 
 * 版本历史：
 * 
 * 2015-10-11   1.0.0版 （龙色波）（创建文件）
 */
package com.dfhc.base.impulsesender.service;

import java.sql.Date;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

import org.quickbundle.project.RmProjectHelper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.dfhc.ISystemConstant;
import com.dfhc.PjException;
import com.dfhc.base.domain.service.DomainService;
import com.dfhc.base.domain.vo.DomainVo;
import com.dfhc.base.impulsesender.IImpulseSenderConstants;
import com.dfhc.base.impulsesender.dao.ImpulseSenderDao;
import com.dfhc.base.impulsesender.vo.ImpulseSenderVo;
import com.dfhc.util.DateUtil;
import com.dfhc.util.StringHelper;
/**
 * 发号器服务
 * 
 * @author 龙色波
 * @see 参见的类
 * @remark 默认将类中的所有public函数纳入事务管理
 */
@Service
@Transactional(readOnly = true)
public class ImpulseSenderService implements IImpulseSenderConstants {

    @Autowired
    /**
     * 发号器数据访问对象
     */
    private ImpulseSenderDao impulseSenderDao;
    @Autowired
    /**
     *  域名服务
     */
    private DomainService domainService;

    /**
     * 插入单条记录
     * 
     * @param vo 用于添加的VO对象
     * @return 若添加成功，返回新生成的Oid
     */
    public String insert(ImpulseSenderVo vo) {
        //检查插入vo合法性
        verifyInsertVo(vo);
        //更新日期为当前日期
        vo.setUpdateDate(new Date(System.currentTimeMillis()));
        String id = impulseSenderDao.insert(vo);
        return id;
    }
    
    /**
     * 插入多条记录
     *
     * @param vos 用于添加的VO对象数组
     * @return 返回新生成的id数组
     */
    public String[] insert(ImpulseSenderVo[] vos) {
    	for(ImpulseSenderVo vo:vos){
    		verifyInsertVo(vo);
    	}
    	String[] ids = impulseSenderDao.insert(vos);
        return ids;
    }

    /**
     * 删除单条记录
     * 
     * @param domainId 用于删除的记录的id
     * @return 成功删除的记录数
     */
    public int delete(String domainId,String sequenceName) {
    	verifyDelete(domainId,sequenceName);
        int sum = impulseSenderDao.delete(domainId,sequenceName);
        return sum;
    }
    /**
     * 校验删除
     * @param domainId 域ID
     * @param sequenceName 序列名称
     */
    private void verifyDelete(String domainId, String sequenceName) {
    	if(StringHelper.isEmpty(domainId)){
    		throw new PjException("域id为空!");
    	}
    	if(StringHelper.isEmpty(sequenceName)){
    		throw new PjException("序列名称为空!");
    	}
    	//系统保留域名下的序列不能修改
        DomainVo domainVo = domainService.get(domainId);
        if(domainVo==null){
        	throw new PjException("域id:"+domainId+"不存在!");
        }
        if(ISystemConstant.SYSTEM_FRAME_DOMAIN_NAME.equalsIgnoreCase(domainVo.getName())){
        	throw new PjException("系统保留域名下序列不允许删除!");
        }    	
	}

	/**
     * 删除多条记录
     * 
     * @param domainIds 用于删除的记录的ids
     * @return 成功删除的记录数
     */
    public int delete(String domainIds[],String sequenceNames[]) {
    	for(int i=0;i<domainIds.length;i++){
    		verifyDelete(domainIds[i], sequenceNames[i]);
    	}
        int sum = impulseSenderDao.delete(domainIds,sequenceNames);
        RmProjectHelper.log(LOG_TYPE_NAME, "发号器删除了{}条记录,ids={}", sum, Arrays.toString(domainIds));
        return sum;
    }

    /**
     * 更新单条记录
     * 
     * @param vo 用于更新的VO对象
     * @return 成功更新的记录数
     */
    public int update(ImpulseSenderVo vo) {
        //检查更新vo合法性
        verifyUpdateVo(vo);
        int sum = impulseSenderDao.update(vo);
        RmProjectHelper.log(LOG_TYPE_NAME, "发号器更新了{}条记录,id={}", sum, "");
        return sum;
    }

    /**
     * 批量更新修改多条记录
     * 
     * @param vos 更新的VO对象数组
     * @return 成功更新的记录最终数量
     */
    public int update(ImpulseSenderVo[] vos) {     
    	for(ImpulseSenderVo vo:vos){
    		verifyUpdateVo(vo);
    	}
       return impulseSenderDao.update(vos);
    }

    /**
     * 批量保存，没有主键的insert，有主键的update
     * 
     * @param vos 更新的VO对象数组
     * @return new int[2]{insert的记录数, update的记录数}   
     */
    public int[] insertUpdateBatch(ImpulseSenderVo[] vos) {
        int[] sum_insert_update = new int[2];
        List<ImpulseSenderVo> lInsert = new ArrayList<ImpulseSenderVo>();
        List<ImpulseSenderVo> lUpdate = new ArrayList<ImpulseSenderVo>();
       
        if(lInsert.size() > 0) {
            sum_insert_update[0] = insert(lInsert.toArray(new ImpulseSenderVo[0])).length;
        }
        if(lUpdate.size() > 0) {
            sum_insert_update[1] = update(lUpdate.toArray(new ImpulseSenderVo[0]));
        }
        return sum_insert_update;
    }

    /**
     * 根据Id进行查询
     * 
     * @param domainId 域id
     * @param sequenceName 序列名称
     * @return 查询到的VO对象
     */
    public ImpulseSenderVo get(String domainId,String sequenceName) {
        ImpulseSenderVo vo = impulseSenderDao.get(domainId,sequenceName);
        return vo;
    }
    
    /**
     * 查询总记录数，带查询条件
     * 
     * @param searchPara 查询条件Map
     * @return 总记录数
     */
    public int getCount(Map<String, Object> searchPara) {
        int sum = impulseSenderDao.getCount(searchPara);
        return sum;
    }

    /**
     * 通过查询条件获得所有的VO对象列表，不带翻页查全部，只查询必要的字段
     *
     * @param searchPara 查询条件Map
     * @param orderStr 排序字段
     * @return 查询到的VO列表
     */
    public List<ImpulseSenderVo> list(Map<String, Object> searchPara, String orderStr) {
        return list(searchPara, orderStr, 1, Integer.MAX_VALUE);
    }

    /**
     * 通过查询条件获得所有的VO对象列表，带翻页，带排序字符，只查询必要的字段
     *
     * @param searchPara 查询条件Map
     * @param orderStr 排序字符
     * @param startIndex 开始位置(第一条是1，第二条是2...)
     * @param size 查询多少条记录
     * @return 查询到的VO列表
     */
    public List<ImpulseSenderVo> list(Map<String, Object> searchPara, String orderStr, int startIndex, int size) {
        return list(searchPara, orderStr, startIndex, size, false);
    }
    
    /**
     * 通过查询条件获得所有的VO对象列表，带翻页，带排序字符，根据selectAllClumn判断是否查询所有字段
     *
     * @param searchPara 查询条件Map
     * @param orderStr 排序字符
     * @param startIndex 开始位置(第一条是1，第二条是2...)
     * @param size 查询多少条记录
     * @param allColumn 是否查询所有列，即 SELECT * FROM ...(适用于导出)
     * @return 查询到的VO列表
     */
    public List<ImpulseSenderVo> list(Map<String, Object> searchPara, String orderStr, int startIndex, int size, boolean allColumn) {
        List<ImpulseSenderVo> lResult = impulseSenderDao.list(searchPara, orderStr, startIndex, size, allColumn);
        return lResult;
    }
    
    /**
     * 校验更新vo
     * @param vo
     */
    private void verifyUpdateVo(ImpulseSenderVo vo) {
        if(vo==null){
           throw new PjException("vo 对象为空!");
        }
        if(StringHelper.isEmpty(vo.getDomainId())){
           throw new PjException("域名ID为空!");
        }
        if(StringHelper.isEmpty(vo.getSequenceName())){
           throw new PjException("序列名称为空!");
        }
//        if(vo.getUpdateDate() == null){
//           throw new PjException("日期为空!");
//        }
        if(vo.getCurrentValue() == null){
           throw new PjException("当前序列值为空!");
        }
        if(StringHelper.isEmpty(vo.getSequenceRule())){
           throw new PjException("序列格式规则为空!");
        }
        if(vo.getSequenceLen() == null){
           throw new PjException("序列值长度为空!");
        }
        //系统保留域名下的序列不能修改
        DomainVo domainVo = domainService.get(vo.getDomainId());
        if(domainVo==null){
        	throw new PjException("域id:"+vo.getDomainId()+"不存在!");
        }
        if(ISystemConstant.SYSTEM_FRAME_DOMAIN_NAME.equalsIgnoreCase(domainVo.getName())){
        	throw new PjException("系统保留域名下序列不允许修改!");
        }
    }
    /**
     * 校验插入vo
     * @param vo
     */
    private void verifyInsertVo(ImpulseSenderVo vo) {
        if(vo==null){
           throw new PjException("vo 对象为空!");
        }
        if(StringHelper.isEmpty(vo.getDomainId())){
           throw new PjException("域名ID为空!");
        }	
        if(StringHelper.isEmpty(vo.getSequenceName())){
           throw new PjException("序列名称为空!");
        }	
//        if(vo.getUpdateDate() == null){
//           throw new PjException("日期为空!");
//        }
        if(vo.getCurrentValue() == null){
           throw new PjException("当前序列值为空!");
        }
        if(StringHelper.isEmpty(vo.getSequenceRule())){
           throw new PjException("序列格式规则为空!");
        }	
        if(vo.getSequenceLen() == null){
           throw new PjException("序列值长度为空!");
        }
    }

}
